#include <iostream>
#include <functional>

using namespace std;

#define ok 0
#define MaxSize 100
#define OVERFLOW -1
#define ERROR 1
typedef int status;

typedef struct{
        int *data;
        int length;
}Sqlist;


//顺序表初始化

status InitList(Sqlist&L){
        L.data=new int[MaxSize];
        if(!L.data)exit(OVERFLOW);

        L.length=0;
        return ok;

}

//按照序号查找
status GetElem(Sqlist L,int i,int &e){

    if(i<1||i>L.length){return ERROR;}
    e=L.data[i-1];
    return ok;
}

//按照元素查找
int locateElem(Sqlist L,int e){
    for(int i=0;i<L.length;i++){
        if(L.data[i]==e){
            return i+1;//序号和数组的下标不一样
        }
    }
    return ok;
}

//插入元素
status ListInsert(Sqlist&L,int i,int e){
    //在顺序表中第i个位置上插入新元素ei
    if(i<=1||i>L.length+1){return ERROR;}
    if(L.length==MaxSize)return ERROR;

    for(int j=L.length-1;j>=i-1;j--){
        L.data[j+1]=L.data[j];
    }

    L.data[i-1]=e;
    ++L.length;
    return ok;
}


status ListDelete(Sqlist &L,int i){

    if(i<1||i>L.length)return ERROR;
    for(int j=i;j<L.length;j++){
        L.data[j-1]=L.data[j];

    }
    --L.length;
    return ok;
}
//#########################################################################################/
//线性表和单链表
typedef struct LNode{
    int data;
    LNode*next;
}LNode,*LinkList;//LinkList为指向结构体 的指针


status InitList(LinkList&L){
    //构造一个空的单链表
    L=new LNode;
    L->next=NULL;
    return ok;
}

//单链表索引取值
status GetElem(LinkList L,int i,int&e){
    LinkList p=L->next;//p指向首源节点
    int j=1;
    while(p&&j<i){
        p=p->next;
        ++j;
    }
    if(!p||j>i)return ERROR;
    e=L->data;
    return ok;
}

//按值查找
LNode*locateElem(LinkList L,int e){
    LinkList p=L->next;//指向首元节点
    while(p&&p->data!=e){
        p=p->next;
    }
    return p;
}

//插入
status ListInsert(LinkList&L,int i,int e){
    //带头节点的链表L中第i个位置插入值为e的新节点
    LinkList p=L;
    int j=0;

    while(p&&j<i-1){
        p=p->next;++j;
        //查找第i-1个节点，p指向该节点
    }
    if(!p||j>i-1){
        return ERROR;
    }
    LinkList s=new LNode;//生成新节点s
    s->data=e;    
    s->next=p->next;
    p->next=s;
    return ok;

}

//删除
status ListDelete(LinkList&L,int i){
    LinkList p;
    int j=0;
    while((p->next)&&(j<i-1)){
        p=p->next;
        ++j;
    }

    if(!(p->next)||(j>i-1))return ERROR;
    LinkList q=p->next;
    p->next=q->next;
    delete q;
    return ok;
}

//头插法
void CreateList_H(LinkList&L,int n){
    L=new LNode;
    L->next=NULL;//建立头节点

    for(int i=0;i<n;i++){
        LinkList p=new LNode;
        std::cin>>p->data;
        p->next=L->next;
        L->next=p;
    }
}

//尾插法
void createList_R(LinkList &L,int n){
    //建立空链表
    L=new LNode;
    L->next=NULL;


    LinkList r=L;
    for(int i=0;i<n;++i){
        LinkList p=new LNode;//生成新节点
        cin>>p->data;
        p->next=NULL;
        r->next=p;//将新节点插入表尾
        r=p;
    }
}


typedef struct DuLNode{
    int data;
    DuLNode*prior;//直接前驱
    DuLNode*next; //直接后继
}DuLNode,*DULinkList;


#if 0
status ListInsert_Dul(DULinkList &L,int i,int e){
    if(!(==GetElem(L,i))){
        return ERROR;
    }
    s=new DuLNode;

    s->data=e;
    s->prior=p->prior;
    p->prior->next=s;
    s->next=p;
    p->prior=s;
    return ok;
}

#endif


#ifdef C

//x线性表的应用
//线性表合并
void MergeList(LinkList&l1,LinkList l2){

    int m=ListLength(L1);
    int n=ListLength(L2);
    for(int i=1;i<n;i++){
        GetElem(l2,i,e);
        if(!LocateElem(L1,e));
    }


}
#endif








